import numpy as np
from tqdm import tqdm
import matplotlib.pyplot as plt
from keras.datasets import mnist
from keras.optimizers import Adam
from keras.models import Sequential, Model
from keras.layers import Dense, Dropout, Flatten, LeakyReLU, Reshape, Input

(X_train, y_train), (X_test, y_test) = mnist.load_data()
X = np.vstack((X_train, X_test))
X = X.astype('float32')

# Normalizamos los datos
X = (X - 127.5) / 127.5

# Imprimimos la forma de los datos
fig = plt.figure()
for i in range(10):
    plt.subplot(2, 5, i+1)
    x_y = X_train[y_train == i]
    plt.imshow(x_y[0], cmap='gray', interpolation='none')
    plt.title("Class %d" % (i))
    plt.xticks([])
    plt.yticks([])

plt.tight_layout()

# Definimos la arquitectura del discriminador
discriminator_input = Input(shape=(28, 28, 1))
x = Flatten()(discriminator_input)
x = Dropout(0.4)(x)
x = Dense(1024, activation=LeakyReLU(alpha=0.2))(x)
x = Dropout(0.4)(x)
x = Dense(512, activation=LeakyReLU(alpha=0.2))(x)
x = Dropout(0.4)(x)
x = Dense(512, activation=LeakyReLU(alpha=0.2))(x)
discriminator_output = Dense(1, activation='sigmoid')(x)

discriminator_model = Model(discriminator_input, discriminator_output)
discriminator_model.compile(optimizer=Adam(learning_rate=0.0002, beta_1=0.5), loss='binary_crossentropy')

discriminator_model.summary()

Model: "model_3"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 input_4 (InputLayer)        [(None, 28, 28, 1)]       0         
                                                                 
 flatten_1 (Flatten)         (None, 784)               0         
                                                                 
 dropout_3 (Dropout)         (None, 784)               0         
                                                                 
 dense_8 (Dense)             (None, 1024)              803840    
                                                                 
 dropout_4 (Dropout)         (None, 1024)              0         
                                                                 
 dense_9 (Dense)             (None, 512)               524800    
                                                                 
 dropout_5 (Dropout)         (None, 512)               0         
                                                                 
 dense_10 (Dense)            (None, 512)               262656    
                                                                 
 dense_11 (Dense)            (None, 1)                 513       
                                                                 
=================================================================
Total params: 1591809 (6.07 MB)
Trainable params: 1591809 (6.07 MB)
Non-trainable params: 0 (0.00 Byte)
_________________________________________________________________

# Definimos la arquitectura del generador
generator_input = Input(shape=(100,))
x = Dense(256, activation=LeakyReLU(alpha=0.2))(generator_input)
x = Dense(512, activation=LeakyReLU(alpha=0.2))(x)
x = Dense(1024, activation=LeakyReLU(alpha=0.2))(x)
x = Dense(784, activation='tanh')(x)
generator_output = Reshape((28, 28, 1))(x)

generator_model = Model(generator_input, generator_output)
generator_model.summary()

Model: "model_4"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 input_5 (InputLayer)        [(None, 100)]             0         
                                                                 
 dense_12 (Dense)            (None, 256)               25856     
                                                                 
 dense_13 (Dense)            (None, 512)               131584    
                                                                 
 dense_14 (Dense)            (None, 1024)              525312    
                                                                 
 dense_15 (Dense)            (None, 784)               803600    
                                                                 
 reshape_1 (Reshape)         (None, 28, 28, 1)         0         
                                                                 
=================================================================
Total params: 1486352 (5.67 MB)
Trainable params: 1486352 (5.67 MB)
Non-trainable params: 0 (0.00 Byte)
_________________________________________________________________

# Definimos la arquitectura del GAN
discriminator_model.trainable = False
gan_input = Input(shape=(100,))
gan_output = discriminator_model(generator_model(gan_input))

gan_model = Model(gan_input, gan_output)
gan_model.compile(optimizer=Adam(learning_rate=0.0002, beta_1=0.5), loss='binary_crossentropy')

gan_model.summary()

Model: "model_5"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 input_6 (InputLayer)        [(None, 100)]             0         
                                                                 
 model_4 (Functional)        (None, 28, 28, 1)         1486352   
                                                                 
 model_3 (Functional)        (None, 1)                 1591809   
                                                                 
=================================================================
Total params: 3078161 (11.74 MB)
Trainable params: 1486352 (5.67 MB)
Non-trainable params: 1591809 (6.07 MB)
_________________________________________________________________

generated_image = generator_model.predict(np.random.randn(1, 100))
plt.imshow(generated_image.reshape(28, 28), cmap='gray')

1/1 [==============================] - 0s 82ms/step

<matplotlib.image.AxesImage at 0x79b97014cfa0>

selected_image = X[4].reshape(1, 28, 28, 1)
plt.imshow(selected_image.reshape(28, 28), cmap='gray')
discriminator_prediction_real = discriminator_model.predict(selected_image)
plt.xlabel(discriminator_prediction_real[0, 0])

1/1 [==============================] - 0s 69ms/step

Text(0.5, 0, '0.52577084')

# Definimos los hiperparámetros
epochs = 100
batch_size = 256
half_batch = batch_size // 2
n = 100
losses = []

# Loop para cada época
for i in range(epochs):
    print('Epochs: ', i)

    # Loop para cada batch
    for j in tqdm(range(len(X) // batch_size)):
        xreal, yreal = X[np.random.randint(0, len(X), half_batch)].reshape(half_batch, 28, 28, 1), np.ones((half_batch, 1))
        xfake, yfake = generator_model.predict(np.random.randn(half_batch, n)), np.zeros((half_batch, 1))
        xfinal, yfinal = np.vstack((xreal, xfake)), np.vstack((yreal, yfake))

        # Perdidas
        d_loss = discriminator_model.train_on_batch(xfinal, yfinal)
        g_loss = gan_model.train_on_batch(np.random.randn(batch_size, n), np.ones((batch_size, 1)))
        losses.append((d_loss, g_loss))


    # graficamos las imágenes generadas
    fig, ax = plt.subplots(5, 5, figsize=(10, 10))
    print("Perdidas: ", d_loss, ",", g_loss)
    for k in range(5):
        for l in range(5):
            generated_image = generator_model.predict(np.random.randn(1, n))
            ax[k, l].imshow(generated_image.reshape(28, 28), cmap='gray')
            ax[k, l].axis('off')

    plt.show()

Epochs:  0

  0%|          | 0/273 [00:00<?, ?it/s]

4/4 [==============================] - 0s 6ms/step

  0%|          | 1/273 [00:02<09:18,  2.05s/it]

4/4 [==============================] - 0s 6ms/step

  1%|          | 2/273 [00:02<04:24,  1.02it/s]

4/4 [==============================] - 0s 6ms/step

  1%|          | 3/273 [00:02<02:57,  1.52it/s]

4/4 [==============================] - 0s 7ms/step

  1%|▏         | 4/273 [00:02<02:11,  2.04it/s]

Javier Mombiela 20067¶

Roberto Rios 20979¶

Laboratorio 5: Generative Adversarial Network (GAN)¶

1. Cargar Data¶

2. Definir Modelos¶

Discriminator¶

Generator¶

3. Combinacion de modelos¶

Predicciones¶

4. Entrenamiento¶